home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_optparse.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  65KB  |  1,804 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import sys
  5. import os
  6. import copy
  7. import unittest
  8. from cStringIO import StringIO
  9. from pprint import pprint
  10. from test import test_support
  11. from optparse import make_option, Option, IndentedHelpFormatter, TitledHelpFormatter, OptionParser, OptionContainer, OptionGroup, SUPPRESS_HELP, SUPPRESS_USAGE, OptionError, OptionConflictError, BadOptionError, OptionValueError, Values, _match_abbrev
  12.  
  13. try:
  14.     (True, False)
  15. except NameError:
  16.     (True, False) = (1, 0)
  17.  
  18.  
  19. class InterceptedError(Exception):
  20.     
  21.     def __init__(self, error_message = None, exit_status = None, exit_message = None):
  22.         self.error_message = error_message
  23.         self.exit_status = exit_status
  24.         self.exit_message = exit_message
  25.  
  26.     
  27.     def __str__(self):
  28.         if not self.error_message and self.exit_message:
  29.             pass
  30.         return 'intercepted error'
  31.  
  32.  
  33.  
  34. class InterceptingOptionParser(OptionParser):
  35.     
  36.     def exit(self, status = 0, msg = None):
  37.         raise InterceptedError(exit_status = status, exit_message = msg)
  38.  
  39.     
  40.     def error(self, msg):
  41.         raise InterceptedError(error_message = msg)
  42.  
  43.  
  44.  
  45. class BaseTest(unittest.TestCase):
  46.     
  47.     def assertParseOK(self, args, expected_opts, expected_positional_args):
  48.         '''Assert the options are what we expected when parsing arguments.
  49.  
  50.         Otherwise, fail with a nicely formatted message.
  51.  
  52.         Keyword arguments:
  53.         args -- A list of arguments to parse with OptionParser.
  54.         expected_opts -- The options expected.
  55.         expected_positional_args -- The positional arguments expected.
  56.  
  57.         Returns the options and positional args for further testing.
  58.         '''
  59.         (options, positional_args) = self.parser.parse_args(args)
  60.         optdict = vars(options)
  61.         self.assertEqual(optdict, expected_opts, '\nOptions are %(optdict)s.\nShould be %(expected_opts)s.\nArgs were %(args)s.' % locals())
  62.         self.assertEqual(positional_args, expected_positional_args, '\nPositional arguments are %(positional_args)s.\nShould be %(expected_positional_args)s.\nArgs were %(args)s.' % locals())
  63.         return (options, positional_args)
  64.  
  65.     
  66.     def assertRaises(self, func, args, kwargs, expected_exception, expected_message):
  67.         '''
  68.         Assert that the expected exception is raised when calling a
  69.         function, and that the right error message is included with
  70.         that exception.
  71.  
  72.         Arguments:
  73.           func -- the function to call
  74.           args -- positional arguments to `func`
  75.           kwargs -- keyword arguments to `func`
  76.           expected_exception -- exception that should be raised
  77.           expected_output -- output we expect to see
  78.  
  79.         Returns the exception raised for further testing.
  80.         '''
  81.         if args is None:
  82.             args = ()
  83.         
  84.         if kwargs is None:
  85.             kwargs = { }
  86.         
  87.         
  88.         try:
  89.             func(*args, **kwargs)
  90.         except expected_exception:
  91.             err = None
  92.             actual_message = str(err)
  93.             self.assertEqual(actual_message, expected_message, "expected exception message:\n'''%(expected_message)s'''\nactual exception message:\n'''%(actual_message)s'''\n" % locals())
  94.             return err
  95.  
  96.         self.fail('expected exception %(expected_exception)s not raised\ncalled %(func)r\nwith args %(args)r\nand kwargs %(kwargs)r\n' % locals())
  97.  
  98.     
  99.     def assertParseFail(self, cmdline_args, expected_output):
  100.         '''
  101.         Assert the parser fails with the expected message.  Caller
  102.         must ensure that self.parser is an InterceptingOptionParser.
  103.         '''
  104.         
  105.         try:
  106.             self.parser.parse_args(cmdline_args)
  107.         except InterceptedError:
  108.             err = None
  109.             self.assertEqual(err.error_message, expected_output)
  110.  
  111.         self.assertFalse('expected parse failure')
  112.  
  113.     
  114.     def assertOutput(self, cmdline_args, expected_output, expected_status = 0, expected_error = None):
  115.         '''Assert the parser prints the expected output on stdout.'''
  116.         save_stdout = sys.stdout
  117.         
  118.         try:
  119.             
  120.             try:
  121.                 sys.stdout = StringIO()
  122.                 self.parser.parse_args(cmdline_args)
  123.             finally:
  124.                 output = sys.stdout.getvalue()
  125.                 sys.stdout = save_stdout
  126.  
  127.         except InterceptedError:
  128.             err = None
  129.             self.assertEqual(output, expected_output)
  130.             self.assertEqual(err.exit_status, expected_status)
  131.             self.assertEqual(err.exit_message, expected_error)
  132.  
  133.         self.assertFalse('expected parser.exit()')
  134.  
  135.     
  136.     def assertTypeError(self, func, expected_message, *args):
  137.         '''Assert that TypeError is raised when executing func.'''
  138.         self.assertRaises(func, args, None, TypeError, expected_message)
  139.  
  140.     
  141.     def assertHelp(self, parser, expected_help):
  142.         actual_help = parser.format_help()
  143.         if actual_help != expected_help:
  144.             raise self.failureException('help text failure; expected:\n"' + expected_help + '"; got:\n"' + actual_help + '"\n')
  145.         
  146.  
  147.  
  148.  
  149. class TestOptionChecks(BaseTest):
  150.     
  151.     def setUp(self):
  152.         self.parser = OptionParser(usage = SUPPRESS_USAGE)
  153.  
  154.     
  155.     def assertOptionError(self, expected_message, args = [], kwargs = { }):
  156.         self.assertRaises(make_option, args, kwargs, OptionError, expected_message)
  157.  
  158.     
  159.     def test_opt_string_empty(self):
  160.         self.assertTypeError(make_option, 'at least one option string must be supplied')
  161.  
  162.     
  163.     def test_opt_string_too_short(self):
  164.         self.assertOptionError("invalid option string 'b': must be at least two characters long", [
  165.             'b'])
  166.  
  167.     
  168.     def test_opt_string_short_invalid(self):
  169.         self.assertOptionError("invalid short option string '--': must be of the form -x, (x any non-dash char)", [
  170.             '--'])
  171.  
  172.     
  173.     def test_opt_string_long_invalid(self):
  174.         self.assertOptionError("invalid long option string '---': must start with --, followed by non-dash", [
  175.             '---'])
  176.  
  177.     
  178.     def test_attr_invalid(self):
  179.         self.assertOptionError('option -b: invalid keyword arguments: foo, bar', [
  180.             '-b'], {
  181.             'foo': None,
  182.             'bar': None })
  183.  
  184.     
  185.     def test_action_invalid(self):
  186.         self.assertOptionError("option -b: invalid action: 'foo'", [
  187.             '-b'], {
  188.             'action': 'foo' })
  189.  
  190.     
  191.     def test_type_invalid(self):
  192.         self.assertOptionError("option -b: invalid option type: 'foo'", [
  193.             '-b'], {
  194.             'type': 'foo' })
  195.         self.assertOptionError("option -b: invalid option type: 'tuple'", [
  196.             '-b'], {
  197.             'type': tuple })
  198.  
  199.     
  200.     def test_no_type_for_action(self):
  201.         self.assertOptionError("option -b: must not supply a type for action 'count'", [
  202.             '-b'], {
  203.             'action': 'count',
  204.             'type': 'int' })
  205.  
  206.     
  207.     def test_no_choices_list(self):
  208.         self.assertOptionError("option -b/--bad: must supply a list of choices for type 'choice'", [
  209.             '-b',
  210.             '--bad'], {
  211.             'type': 'choice' })
  212.  
  213.     
  214.     def test_bad_choices_list(self):
  215.         typename = type('').__name__
  216.         self.assertOptionError("option -b/--bad: choices must be a list of strings ('%s' supplied)" % typename, [
  217.             '-b',
  218.             '--bad'], {
  219.             'type': 'choice',
  220.             'choices': 'bad choices' })
  221.  
  222.     
  223.     def test_no_choices_for_type(self):
  224.         self.assertOptionError("option -b: must not supply choices for type 'int'", [
  225.             '-b'], {
  226.             'type': 'int',
  227.             'choices': 'bad' })
  228.  
  229.     
  230.     def test_no_const_for_action(self):
  231.         self.assertOptionError("option -b: 'const' must not be supplied for action 'store'", [
  232.             '-b'], {
  233.             'action': 'store',
  234.             'const': 1 })
  235.  
  236.     
  237.     def test_no_nargs_for_action(self):
  238.         self.assertOptionError("option -b: 'nargs' must not be supplied for action 'count'", [
  239.             '-b'], {
  240.             'action': 'count',
  241.             'nargs': 2 })
  242.  
  243.     
  244.     def test_callback_not_callable(self):
  245.         self.assertOptionError("option -b: callback not callable: 'foo'", [
  246.             '-b'], {
  247.             'action': 'callback',
  248.             'callback': 'foo' })
  249.  
  250.     
  251.     def dummy(self):
  252.         pass
  253.  
  254.     
  255.     def test_callback_args_no_tuple(self):
  256.         self.assertOptionError("option -b: callback_args, if supplied, must be a tuple: not 'foo'", [
  257.             '-b'], {
  258.             'action': 'callback',
  259.             'callback': self.dummy,
  260.             'callback_args': 'foo' })
  261.  
  262.     
  263.     def test_callback_kwargs_no_dict(self):
  264.         self.assertOptionError("option -b: callback_kwargs, if supplied, must be a dict: not 'foo'", [
  265.             '-b'], {
  266.             'action': 'callback',
  267.             'callback': self.dummy,
  268.             'callback_kwargs': 'foo' })
  269.  
  270.     
  271.     def test_no_callback_for_action(self):
  272.         self.assertOptionError("option -b: callback supplied ('foo') for non-callback option", [
  273.             '-b'], {
  274.             'action': 'store',
  275.             'callback': 'foo' })
  276.  
  277.     
  278.     def test_no_callback_args_for_action(self):
  279.         self.assertOptionError('option -b: callback_args supplied for non-callback option', [
  280.             '-b'], {
  281.             'action': 'store',
  282.             'callback_args': 'foo' })
  283.  
  284.     
  285.     def test_no_callback_kwargs_for_action(self):
  286.         self.assertOptionError('option -b: callback_kwargs supplied for non-callback option', [
  287.             '-b'], {
  288.             'action': 'store',
  289.             'callback_kwargs': 'foo' })
  290.  
  291.  
  292.  
  293. class TestOptionParser(BaseTest):
  294.     
  295.     def setUp(self):
  296.         self.parser = OptionParser()
  297.         self.parser.add_option('-v', '--verbose', '-n', '--noisy', action = 'store_true', dest = 'verbose')
  298.         self.parser.add_option('-q', '--quiet', '--silent', action = 'store_false', dest = 'verbose')
  299.  
  300.     
  301.     def test_add_option_no_Option(self):
  302.         self.assertTypeError(self.parser.add_option, 'not an Option instance: None', None)
  303.  
  304.     
  305.     def test_add_option_invalid_arguments(self):
  306.         self.assertTypeError(self.parser.add_option, 'invalid arguments', None, None)
  307.  
  308.     
  309.     def test_get_option(self):
  310.         opt1 = self.parser.get_option('-v')
  311.         self.assert_(isinstance(opt1, Option))
  312.         self.assertEqual(opt1._short_opts, [
  313.             '-v',
  314.             '-n'])
  315.         self.assertEqual(opt1._long_opts, [
  316.             '--verbose',
  317.             '--noisy'])
  318.         self.assertEqual(opt1.action, 'store_true')
  319.         self.assertEqual(opt1.dest, 'verbose')
  320.  
  321.     
  322.     def test_get_option_equals(self):
  323.         opt1 = self.parser.get_option('-v')
  324.         opt2 = self.parser.get_option('--verbose')
  325.         opt3 = self.parser.get_option('-n')
  326.         opt4 = self.parser.get_option('--noisy')
  327.         None(self.assert_ if opt2 is opt2 and opt3 is opt3 else opt3 is opt4)
  328.  
  329.     
  330.     def test_has_option(self):
  331.         self.assert_(self.parser.has_option('-v'))
  332.         self.assert_(self.parser.has_option('--verbose'))
  333.  
  334.     
  335.     def assert_removed(self):
  336.         self.assert_(self.parser.get_option('-v') is None)
  337.         self.assert_(self.parser.get_option('--verbose') is None)
  338.         self.assert_(self.parser.get_option('-n') is None)
  339.         self.assert_(self.parser.get_option('--noisy') is None)
  340.         self.failIf(self.parser.has_option('-v'))
  341.         self.failIf(self.parser.has_option('--verbose'))
  342.         self.failIf(self.parser.has_option('-n'))
  343.         self.failIf(self.parser.has_option('--noisy'))
  344.         self.assert_(self.parser.has_option('-q'))
  345.         self.assert_(self.parser.has_option('--silent'))
  346.  
  347.     
  348.     def test_remove_short_opt(self):
  349.         self.parser.remove_option('-n')
  350.         self.assert_removed()
  351.  
  352.     
  353.     def test_remove_long_opt(self):
  354.         self.parser.remove_option('--verbose')
  355.         self.assert_removed()
  356.  
  357.     
  358.     def test_remove_nonexistent(self):
  359.         self.assertRaises(self.parser.remove_option, ('foo',), None, ValueError, "no such option 'foo'")
  360.  
  361.  
  362.  
  363. class TestOptionValues(BaseTest):
  364.     
  365.     def setUp(self):
  366.         pass
  367.  
  368.     
  369.     def test_basics(self):
  370.         values = Values()
  371.         self.assertEqual(vars(values), { })
  372.         self.assertEqual(values, { })
  373.         self.assertNotEqual(values, {
  374.             'foo': 'bar' })
  375.         self.assertNotEqual(values, '')
  376.         dict = {
  377.             'foo': 'bar',
  378.             'baz': 42 }
  379.         values = Values(defaults = dict)
  380.         self.assertEqual(vars(values), dict)
  381.         self.assertEqual(values, dict)
  382.         self.assertNotEqual(values, {
  383.             'foo': 'bar' })
  384.         self.assertNotEqual(values, { })
  385.         self.assertNotEqual(values, '')
  386.         self.assertNotEqual(values, [])
  387.  
  388.  
  389.  
  390. class TestTypeAliases(BaseTest):
  391.     
  392.     def setUp(self):
  393.         self.parser = OptionParser()
  394.  
  395.     
  396.     def test_type_aliases(self):
  397.         self.parser.add_option('-x', type = int)
  398.         self.parser.add_option('-s', type = str)
  399.         self.parser.add_option('-t', type = 'str')
  400.         self.assertEquals(self.parser.get_option('-x').type, 'int')
  401.         self.assertEquals(self.parser.get_option('-s').type, 'string')
  402.         self.assertEquals(self.parser.get_option('-t').type, 'string')
  403.  
  404.  
  405. _time_units = {
  406.     's': 1,
  407.     'm': 60,
  408.     'h': 60 * 60,
  409.     'd': 60 * 60 * 24 }
  410.  
  411. def _check_duration(option, opt, value):
  412.     
  413.     try:
  414.         if value[-1].isdigit():
  415.             return int(value)
  416.         else:
  417.             return int(value[:-1]) * _time_units[value[-1]]
  418.     except ValueError:
  419.         IndexError = None
  420.         raise OptionValueError('option %s: invalid duration: %r' % (opt, value))
  421.  
  422.  
  423.  
  424. class DurationOption(Option):
  425.     TYPES = Option.TYPES + ('duration',)
  426.     TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
  427.     TYPE_CHECKER['duration'] = _check_duration
  428.  
  429.  
  430. class TestDefaultValues(BaseTest):
  431.     
  432.     def setUp(self):
  433.         self.parser = OptionParser()
  434.         self.parser.add_option('-v', '--verbose', default = True)
  435.         self.parser.add_option('-q', '--quiet', dest = 'verbose')
  436.         self.parser.add_option('-n', type = 'int', default = 37)
  437.         self.parser.add_option('-m', type = 'int')
  438.         self.parser.add_option('-s', default = 'foo')
  439.         self.parser.add_option('-t')
  440.         self.parser.add_option('-u', default = None)
  441.         self.expected = {
  442.             'verbose': True,
  443.             'n': 37,
  444.             'm': None,
  445.             's': 'foo',
  446.             't': None,
  447.             'u': None }
  448.  
  449.     
  450.     def test_basic_defaults(self):
  451.         self.assertEqual(self.parser.get_default_values(), self.expected)
  452.  
  453.     
  454.     def test_mixed_defaults_post(self):
  455.         self.parser.set_defaults(n = 42, m = -100)
  456.         self.expected.update({
  457.             'n': 42,
  458.             'm': -100 })
  459.         self.assertEqual(self.parser.get_default_values(), self.expected)
  460.  
  461.     
  462.     def test_mixed_defaults_pre(self):
  463.         self.parser.set_defaults(x = 'barf', y = 'blah')
  464.         self.parser.add_option('-x', default = 'frob')
  465.         self.parser.add_option('-y')
  466.         self.expected.update({
  467.             'x': 'frob',
  468.             'y': 'blah' })
  469.         self.assertEqual(self.parser.get_default_values(), self.expected)
  470.         self.parser.remove_option('-y')
  471.         self.parser.add_option('-y', default = None)
  472.         self.expected.update({
  473.             'y': None })
  474.         self.assertEqual(self.parser.get_default_values(), self.expected)
  475.  
  476.     
  477.     def test_process_default(self):
  478.         self.parser.option_class = DurationOption
  479.         self.parser.add_option('-d', type = 'duration', default = 300)
  480.         self.parser.add_option('-e', type = 'duration', default = '6m')
  481.         self.parser.set_defaults(n = '42')
  482.         self.expected.update({
  483.             'd': 300,
  484.             'e': 360,
  485.             'n': 42 })
  486.         self.assertEqual(self.parser.get_default_values(), self.expected)
  487.         self.parser.set_process_default_values(False)
  488.         self.expected.update({
  489.             'd': 300,
  490.             'e': '6m',
  491.             'n': '42' })
  492.         self.assertEqual(self.parser.get_default_values(), self.expected)
  493.  
  494.  
  495.  
  496. class TestProgName(BaseTest):
  497.     '''
  498.     Test that %prog expands to the right thing in usage, version,
  499.     and help strings.
  500.     '''
  501.     
  502.     def assertUsage(self, parser, expected_usage):
  503.         self.assertEqual(parser.get_usage(), expected_usage)
  504.  
  505.     
  506.     def assertVersion(self, parser, expected_version):
  507.         self.assertEqual(parser.get_version(), expected_version)
  508.  
  509.     
  510.     def test_default_progname(self):
  511.         save_argv = sys.argv[:]
  512.         
  513.         try:
  514.             sys.argv[0] = os.path.join('foo', 'bar', 'baz.py')
  515.             parser = OptionParser('usage: %prog ...', version = '%prog 1.2')
  516.             expected_usage = 'usage: baz.py ...\n'
  517.             self.assertUsage(parser, expected_usage)
  518.             self.assertVersion(parser, 'baz.py 1.2')
  519.             self.assertHelp(parser, expected_usage + '\n' + "options:\n  --version   show program's version number and exit\n  -h, --help  show this help message and exit\n")
  520.         finally:
  521.             sys.argv[:] = save_argv
  522.  
  523.  
  524.     
  525.     def test_custom_progname(self):
  526.         parser = OptionParser(prog = 'thingy', version = '%prog 0.1', usage = '%prog arg arg')
  527.         parser.remove_option('-h')
  528.         parser.remove_option('--version')
  529.         expected_usage = 'usage: thingy arg arg\n'
  530.         self.assertUsage(parser, expected_usage)
  531.         self.assertVersion(parser, 'thingy 0.1')
  532.         self.assertHelp(parser, expected_usage + '\n')
  533.  
  534.  
  535.  
  536. class TestExpandDefaults(BaseTest):
  537.     
  538.     def setUp(self):
  539.         self.parser = OptionParser(prog = 'test')
  540.         self.help_prefix = 'usage: test [options]\n\noptions:\n  -h, --help            show this help message and exit\n'
  541.         self.file_help = 'read from FILE [default: %default]'
  542.         self.expected_help_file = self.help_prefix + '  -f FILE, --file=FILE  read from FILE [default: foo.txt]\n'
  543.         self.expected_help_none = self.help_prefix + '  -f FILE, --file=FILE  read from FILE [default: none]\n'
  544.  
  545.     
  546.     def test_option_default(self):
  547.         self.parser.add_option('-f', '--file', default = 'foo.txt', help = self.file_help)
  548.         self.assertHelp(self.parser, self.expected_help_file)
  549.  
  550.     
  551.     def test_parser_default_1(self):
  552.         self.parser.add_option('-f', '--file', help = self.file_help)
  553.         self.parser.set_default('file', 'foo.txt')
  554.         self.assertHelp(self.parser, self.expected_help_file)
  555.  
  556.     
  557.     def test_parser_default_2(self):
  558.         self.parser.add_option('-f', '--file', help = self.file_help)
  559.         self.parser.set_defaults(file = 'foo.txt')
  560.         self.assertHelp(self.parser, self.expected_help_file)
  561.  
  562.     
  563.     def test_no_default(self):
  564.         self.parser.add_option('-f', '--file', help = self.file_help)
  565.         self.assertHelp(self.parser, self.expected_help_none)
  566.  
  567.     
  568.     def test_default_none_1(self):
  569.         self.parser.add_option('-f', '--file', default = None, help = self.file_help)
  570.         self.assertHelp(self.parser, self.expected_help_none)
  571.  
  572.     
  573.     def test_default_none_2(self):
  574.         self.parser.add_option('-f', '--file', help = self.file_help)
  575.         self.parser.set_defaults(file = None)
  576.         self.assertHelp(self.parser, self.expected_help_none)
  577.  
  578.     
  579.     def test_float_default(self):
  580.         self.parser.add_option('-p', '--prob', help = 'blow up with probability PROB [default: %default]')
  581.         self.parser.set_defaults(prob = 0.42999999999999999)
  582.         expected_help = self.help_prefix + '  -p PROB, --prob=PROB  blow up with probability PROB [default: 0.43]\n'
  583.         self.assertHelp(self.parser, expected_help)
  584.  
  585.     
  586.     def test_alt_expand(self):
  587.         self.parser.add_option('-f', '--file', default = 'foo.txt', help = 'read from FILE [default: *DEFAULT*]')
  588.         self.parser.formatter.default_tag = '*DEFAULT*'
  589.         self.assertHelp(self.parser, self.expected_help_file)
  590.  
  591.     
  592.     def test_no_expand(self):
  593.         self.parser.add_option('-f', '--file', default = 'foo.txt', help = 'read from %default file')
  594.         self.parser.formatter.default_tag = None
  595.         expected_help = self.help_prefix + '  -f FILE, --file=FILE  read from %default file\n'
  596.         self.assertHelp(self.parser, expected_help)
  597.  
  598.  
  599.  
  600. class TestStandard(BaseTest):
  601.     
  602.     def setUp(self):
  603.         options = [
  604.             make_option('-a', type = 'string'),
  605.             make_option('-b', '--boo', type = 'int', dest = 'boo'),
  606.             make_option('--foo', action = 'append')]
  607.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE, option_list = options)
  608.  
  609.     
  610.     def test_required_value(self):
  611.         self.assertParseFail([
  612.             '-a'], '-a option requires an argument')
  613.  
  614.     
  615.     def test_invalid_integer(self):
  616.         self.assertParseFail([
  617.             '-b',
  618.             '5x'], "option -b: invalid integer value: '5x'")
  619.  
  620.     
  621.     def test_no_such_option(self):
  622.         self.assertParseFail([
  623.             '--boo13'], 'no such option: --boo13')
  624.  
  625.     
  626.     def test_long_invalid_integer(self):
  627.         self.assertParseFail([
  628.             '--boo=x5'], "option --boo: invalid integer value: 'x5'")
  629.  
  630.     
  631.     def test_empty(self):
  632.         self.assertParseOK([], {
  633.             'a': None,
  634.             'boo': None,
  635.             'foo': None }, [])
  636.  
  637.     
  638.     def test_shortopt_empty_longopt_append(self):
  639.         self.assertParseOK([
  640.             '-a',
  641.             '',
  642.             '--foo=blah',
  643.             '--foo='], {
  644.             'a': '',
  645.             'boo': None,
  646.             'foo': [
  647.                 'blah',
  648.                 ''] }, [])
  649.  
  650.     
  651.     def test_long_option_append(self):
  652.         self.assertParseOK([
  653.             '--foo',
  654.             'bar',
  655.             '--foo',
  656.             '',
  657.             '--foo=x'], {
  658.             'a': None,
  659.             'boo': None,
  660.             'foo': [
  661.                 'bar',
  662.                 '',
  663.                 'x'] }, [])
  664.  
  665.     
  666.     def test_option_argument_joined(self):
  667.         self.assertParseOK([
  668.             '-abc'], {
  669.             'a': 'bc',
  670.             'boo': None,
  671.             'foo': None }, [])
  672.  
  673.     
  674.     def test_option_argument_split(self):
  675.         self.assertParseOK([
  676.             '-a',
  677.             '34'], {
  678.             'a': '34',
  679.             'boo': None,
  680.             'foo': None }, [])
  681.  
  682.     
  683.     def test_option_argument_joined_integer(self):
  684.         self.assertParseOK([
  685.             '-b34'], {
  686.             'a': None,
  687.             'boo': 34,
  688.             'foo': None }, [])
  689.  
  690.     
  691.     def test_option_argument_split_negative_integer(self):
  692.         self.assertParseOK([
  693.             '-b',
  694.             '-5'], {
  695.             'a': None,
  696.             'boo': -5,
  697.             'foo': None }, [])
  698.  
  699.     
  700.     def test_long_option_argument_joined(self):
  701.         self.assertParseOK([
  702.             '--boo=13'], {
  703.             'a': None,
  704.             'boo': 13,
  705.             'foo': None }, [])
  706.  
  707.     
  708.     def test_long_option_argument_split(self):
  709.         self.assertParseOK([
  710.             '--boo',
  711.             '111'], {
  712.             'a': None,
  713.             'boo': 111,
  714.             'foo': None }, [])
  715.  
  716.     
  717.     def test_long_option_short_option(self):
  718.         self.assertParseOK([
  719.             '--foo=bar',
  720.             '-axyz'], {
  721.             'a': 'xyz',
  722.             'boo': None,
  723.             'foo': [
  724.                 'bar'] }, [])
  725.  
  726.     
  727.     def test_abbrev_long_option(self):
  728.         self.assertParseOK([
  729.             '--f=bar',
  730.             '-axyz'], {
  731.             'a': 'xyz',
  732.             'boo': None,
  733.             'foo': [
  734.                 'bar'] }, [])
  735.  
  736.     
  737.     def test_defaults(self):
  738.         (options, args) = self.parser.parse_args([])
  739.         defaults = self.parser.get_default_values()
  740.         self.assertEqual(vars(defaults), vars(options))
  741.  
  742.     
  743.     def test_ambiguous_option(self):
  744.         self.parser.add_option('--foz', action = 'store', type = 'string', dest = 'foo')
  745.         possibilities = ', '.join({
  746.             '--foz': None,
  747.             '--foo': None }.keys())
  748.         self.assertParseFail([
  749.             '--f=bar'], 'ambiguous option: --f (%s?)' % possibilities)
  750.  
  751.     
  752.     def test_short_and_long_option_split(self):
  753.         (self.assertParseOK([
  754.             '-a',
  755.             'xyz',
  756.             '--foo',
  757.             'bar'], {
  758.             'a': 'xyz',
  759.             'boo': None,
  760.             'foo': [
  761.                 'bar'] }, []),)
  762.  
  763.     
  764.     def test_short_option_split_long_option_append(self):
  765.         self.assertParseOK([
  766.             '--foo=bar',
  767.             '-b',
  768.             '123',
  769.             '--foo',
  770.             'baz'], {
  771.             'a': None,
  772.             'boo': 123,
  773.             'foo': [
  774.                 'bar',
  775.                 'baz'] }, [])
  776.  
  777.     
  778.     def test_short_option_split_one_positional_arg(self):
  779.         (self.assertParseOK([
  780.             '-a',
  781.             'foo',
  782.             'bar'], {
  783.             'a': 'foo',
  784.             'boo': None,
  785.             'foo': None }, [
  786.             'bar']),)
  787.  
  788.     
  789.     def test_short_option_consumes_separator(self):
  790.         (self.assertParseOK([
  791.             '-a',
  792.             '--',
  793.             'foo',
  794.             'bar'], {
  795.             'a': '--',
  796.             'boo': None,
  797.             'foo': None }, [
  798.             'foo',
  799.             'bar']),)
  800.  
  801.     
  802.     def test_short_option_joined_and_separator(self):
  803.         (self.assertParseOK([
  804.             '-ab',
  805.             '--',
  806.             '--foo',
  807.             'bar'], {
  808.             'a': 'b',
  809.             'boo': None,
  810.             'foo': None }, [
  811.             '--foo',
  812.             'bar']),)
  813.  
  814.     
  815.     def test_invalid_option_becomes_positional_arg(self):
  816.         self.assertParseOK([
  817.             '-ab',
  818.             '-',
  819.             '--foo',
  820.             'bar'], {
  821.             'a': 'b',
  822.             'boo': None,
  823.             'foo': [
  824.                 'bar'] }, [
  825.             '-'])
  826.  
  827.     
  828.     def test_no_append_versus_append(self):
  829.         self.assertParseOK([
  830.             '-b3',
  831.             '-b',
  832.             '5',
  833.             '--foo=bar',
  834.             '--foo',
  835.             'baz'], {
  836.             'a': None,
  837.             'boo': 5,
  838.             'foo': [
  839.                 'bar',
  840.                 'baz'] }, [])
  841.  
  842.     
  843.     def test_option_consumes_optionlike_string(self):
  844.         self.assertParseOK([
  845.             '-a',
  846.             '-b3'], {
  847.             'a': '-b3',
  848.             'boo': None,
  849.             'foo': None }, [])
  850.  
  851.  
  852.  
  853. class TestBool(BaseTest):
  854.     
  855.     def setUp(self):
  856.         options = [
  857.             make_option('-v', '--verbose', action = 'store_true', dest = 'verbose', default = ''),
  858.             make_option('-q', '--quiet', action = 'store_false', dest = 'verbose')]
  859.         self.parser = OptionParser(option_list = options)
  860.  
  861.     
  862.     def test_bool_default(self):
  863.         self.assertParseOK([], {
  864.             'verbose': '' }, [])
  865.  
  866.     
  867.     def test_bool_false(self):
  868.         (options, args) = self.assertParseOK([
  869.             '-q'], {
  870.             'verbose': 0 }, [])
  871.         if hasattr(__builtins__, 'False'):
  872.             self.failUnless(options.verbose is False)
  873.         
  874.  
  875.     
  876.     def test_bool_true(self):
  877.         (options, args) = self.assertParseOK([
  878.             '-v'], {
  879.             'verbose': 1 }, [])
  880.         if hasattr(__builtins__, 'True'):
  881.             self.failUnless(options.verbose is True)
  882.         
  883.  
  884.     
  885.     def test_bool_flicker_on_and_off(self):
  886.         self.assertParseOK([
  887.             '-qvq',
  888.             '-q',
  889.             '-v'], {
  890.             'verbose': 1 }, [])
  891.  
  892.  
  893.  
  894. class TestChoice(BaseTest):
  895.     
  896.     def setUp(self):
  897.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  898.         self.parser.add_option('-c', action = 'store', type = 'choice', dest = 'choice', choices = [
  899.             'one',
  900.             'two',
  901.             'three'])
  902.  
  903.     
  904.     def test_valid_choice(self):
  905.         self.assertParseOK([
  906.             '-c',
  907.             'one',
  908.             'xyz'], {
  909.             'choice': 'one' }, [
  910.             'xyz'])
  911.  
  912.     
  913.     def test_invalid_choice(self):
  914.         self.assertParseFail([
  915.             '-c',
  916.             'four',
  917.             'abc'], "option -c: invalid choice: 'four' (choose from 'one', 'two', 'three')")
  918.  
  919.     
  920.     def test_add_choice_option(self):
  921.         self.parser.add_option('-d', '--default', choices = [
  922.             'four',
  923.             'five',
  924.             'six'])
  925.         opt = self.parser.get_option('-d')
  926.         self.assertEqual(opt.type, 'choice')
  927.         self.assertEqual(opt.action, 'store')
  928.  
  929.  
  930.  
  931. class TestCount(BaseTest):
  932.     
  933.     def setUp(self):
  934.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  935.         self.v_opt = make_option('-v', action = 'count', dest = 'verbose')
  936.         self.parser.add_option(self.v_opt)
  937.         self.parser.add_option('--verbose', type = 'int', dest = 'verbose')
  938.         self.parser.add_option('-q', '--quiet', action = 'store_const', dest = 'verbose', const = 0)
  939.  
  940.     
  941.     def test_empty(self):
  942.         self.assertParseOK([], {
  943.             'verbose': None }, [])
  944.  
  945.     
  946.     def test_count_one(self):
  947.         self.assertParseOK([
  948.             '-v'], {
  949.             'verbose': 1 }, [])
  950.  
  951.     
  952.     def test_count_three(self):
  953.         self.assertParseOK([
  954.             '-vvv'], {
  955.             'verbose': 3 }, [])
  956.  
  957.     
  958.     def test_count_three_apart(self):
  959.         self.assertParseOK([
  960.             '-v',
  961.             '-v',
  962.             '-v'], {
  963.             'verbose': 3 }, [])
  964.  
  965.     
  966.     def test_count_override_amount(self):
  967.         self.assertParseOK([
  968.             '-vvv',
  969.             '--verbose=2'], {
  970.             'verbose': 2 }, [])
  971.  
  972.     
  973.     def test_count_override_quiet(self):
  974.         self.assertParseOK([
  975.             '-vvv',
  976.             '--verbose=2',
  977.             '-q'], {
  978.             'verbose': 0 }, [])
  979.  
  980.     
  981.     def test_count_overriding(self):
  982.         self.assertParseOK([
  983.             '-vvv',
  984.             '--verbose=2',
  985.             '-q',
  986.             '-v'], {
  987.             'verbose': 1 }, [])
  988.  
  989.     
  990.     def test_count_interspersed_args(self):
  991.         self.assertParseOK([
  992.             '--quiet',
  993.             '3',
  994.             '-v'], {
  995.             'verbose': 1 }, [
  996.             '3'])
  997.  
  998.     
  999.     def test_count_no_interspersed_args(self):
  1000.         self.parser.disable_interspersed_args()
  1001.         self.assertParseOK([
  1002.             '--quiet',
  1003.             '3',
  1004.             '-v'], {
  1005.             'verbose': 0 }, [
  1006.             '3',
  1007.             '-v'])
  1008.  
  1009.     
  1010.     def test_count_no_such_option(self):
  1011.         self.assertParseFail([
  1012.             '-q3',
  1013.             '-v'], 'no such option: -3')
  1014.  
  1015.     
  1016.     def test_count_option_no_value(self):
  1017.         self.assertParseFail([
  1018.             '--quiet=3',
  1019.             '-v'], '--quiet option does not take a value')
  1020.  
  1021.     
  1022.     def test_count_with_default(self):
  1023.         self.parser.set_default('verbose', 0)
  1024.         self.assertParseOK([], {
  1025.             'verbose': 0 }, [])
  1026.  
  1027.     
  1028.     def test_count_overriding_default(self):
  1029.         self.parser.set_default('verbose', 0)
  1030.         self.assertParseOK([
  1031.             '-vvv',
  1032.             '--verbose=2',
  1033.             '-q',
  1034.             '-v'], {
  1035.             'verbose': 1 }, [])
  1036.  
  1037.  
  1038.  
  1039. class TestMultipleArgs(BaseTest):
  1040.     
  1041.     def setUp(self):
  1042.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  1043.         self.parser.add_option('-p', '--point', action = 'store', nargs = 3, type = 'float', dest = 'point')
  1044.  
  1045.     
  1046.     def test_nargs_with_positional_args(self):
  1047.         self.assertParseOK([
  1048.             'foo',
  1049.             '-p',
  1050.             '1',
  1051.             '2.5',
  1052.             '-4.3',
  1053.             'xyz'], {
  1054.             'point': (1.0, 2.5, -4.2999999999999998) }, [
  1055.             'foo',
  1056.             'xyz'])
  1057.  
  1058.     
  1059.     def test_nargs_long_opt(self):
  1060.         self.assertParseOK([
  1061.             '--point',
  1062.             '-1',
  1063.             '2.5',
  1064.             '-0',
  1065.             'xyz'], {
  1066.             'point': (-1.0, 2.5, -0.0) }, [
  1067.             'xyz'])
  1068.  
  1069.     
  1070.     def test_nargs_invalid_float_value(self):
  1071.         self.assertParseFail([
  1072.             '-p',
  1073.             '1.0',
  1074.             '2x',
  1075.             '3.5'], "option -p: invalid floating-point value: '2x'")
  1076.  
  1077.     
  1078.     def test_nargs_required_values(self):
  1079.         self.assertParseFail([
  1080.             '--point',
  1081.             '1.0',
  1082.             '3.5'], '--point option requires 3 arguments')
  1083.  
  1084.  
  1085.  
  1086. class TestMultipleArgsAppend(BaseTest):
  1087.     
  1088.     def setUp(self):
  1089.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  1090.         self.parser.add_option('-p', '--point', action = 'store', nargs = 3, type = 'float', dest = 'point')
  1091.         self.parser.add_option('-f', '--foo', action = 'append', nargs = 2, type = 'int', dest = 'foo')
  1092.  
  1093.     
  1094.     def test_nargs_append(self):
  1095.         self.assertParseOK([
  1096.             '-f',
  1097.             '4',
  1098.             '-3',
  1099.             'blah',
  1100.             '--foo',
  1101.             '1',
  1102.             '666'], {
  1103.             'point': None,
  1104.             'foo': [
  1105.                 (4, -3),
  1106.                 (1, 666)] }, [
  1107.             'blah'])
  1108.  
  1109.     
  1110.     def test_nargs_append_required_values(self):
  1111.         self.assertParseFail([
  1112.             '-f4,3'], '-f option requires 2 arguments')
  1113.  
  1114.     
  1115.     def test_nargs_append_simple(self):
  1116.         self.assertParseOK([
  1117.             '--foo=3',
  1118.             '4'], {
  1119.             'point': None,
  1120.             'foo': [
  1121.                 (3, 4)] }, [])
  1122.  
  1123.  
  1124.  
  1125. class TestVersion(BaseTest):
  1126.     
  1127.     def test_version(self):
  1128.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE, version = '%prog 0.1')
  1129.         save_argv = sys.argv[:]
  1130.         
  1131.         try:
  1132.             sys.argv[0] = os.path.join(os.curdir, 'foo', 'bar')
  1133.             self.assertOutput([
  1134.                 '--version'], 'bar 0.1\n')
  1135.         finally:
  1136.             sys.argv[:] = save_argv
  1137.  
  1138.  
  1139.     
  1140.     def test_no_version(self):
  1141.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  1142.         self.assertParseFail([
  1143.             '--version'], 'no such option: --version')
  1144.  
  1145.  
  1146.  
  1147. class TestConflictingDefaults(BaseTest):
  1148.     '''Conflicting default values: the last one should win.'''
  1149.     
  1150.     def setUp(self):
  1151.         self.parser = OptionParser(option_list = [
  1152.             make_option('-v', action = 'store_true', dest = 'verbose', default = 1)])
  1153.  
  1154.     
  1155.     def test_conflict_default(self):
  1156.         self.parser.add_option('-q', action = 'store_false', dest = 'verbose', default = 0)
  1157.         self.assertParseOK([], {
  1158.             'verbose': 0 }, [])
  1159.  
  1160.     
  1161.     def test_conflict_default_none(self):
  1162.         self.parser.add_option('-q', action = 'store_false', dest = 'verbose', default = None)
  1163.         self.assertParseOK([], {
  1164.             'verbose': None }, [])
  1165.  
  1166.  
  1167.  
  1168. class TestOptionGroup(BaseTest):
  1169.     
  1170.     def setUp(self):
  1171.         self.parser = OptionParser(usage = SUPPRESS_USAGE)
  1172.  
  1173.     
  1174.     def test_option_group_create_instance(self):
  1175.         group = OptionGroup(self.parser, 'Spam')
  1176.         self.parser.add_option_group(group)
  1177.         group.add_option('--spam', action = 'store_true', help = 'spam spam spam spam')
  1178.         self.assertParseOK([
  1179.             '--spam'], {
  1180.             'spam': 1 }, [])
  1181.  
  1182.     
  1183.     def test_add_group_no_group(self):
  1184.         self.assertTypeError(self.parser.add_option_group, 'not an OptionGroup instance: None', None)
  1185.  
  1186.     
  1187.     def test_add_group_invalid_arguments(self):
  1188.         self.assertTypeError(self.parser.add_option_group, 'invalid arguments', None, None)
  1189.  
  1190.     
  1191.     def test_add_group_wrong_parser(self):
  1192.         group = OptionGroup(self.parser, 'Spam')
  1193.         group.parser = OptionParser()
  1194.         self.assertRaises(self.parser.add_option_group, (group,), None, ValueError, 'invalid OptionGroup (wrong parser)')
  1195.  
  1196.     
  1197.     def test_group_manipulate(self):
  1198.         group = self.parser.add_option_group('Group 2', description = 'Some more options')
  1199.         group.set_title('Bacon')
  1200.         group.add_option('--bacon', type = 'int')
  1201.         self.assert_(self.parser.get_option_group('--bacon'), group)
  1202.  
  1203.  
  1204.  
  1205. class TestExtendAddTypes(BaseTest):
  1206.     
  1207.     def setUp(self):
  1208.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE, option_class = self.MyOption)
  1209.         self.parser.add_option('-a', None, type = 'string', dest = 'a')
  1210.         self.parser.add_option('-f', '--file', type = 'file', dest = 'file')
  1211.  
  1212.     
  1213.     class MyOption(Option):
  1214.         
  1215.         def check_file(option, opt, value):
  1216.             if not os.path.exists(value):
  1217.                 raise OptionValueError('%s: file does not exist' % value)
  1218.             elif not os.path.isfile(value):
  1219.                 raise OptionValueError('%s: not a regular file' % value)
  1220.             
  1221.             return value
  1222.  
  1223.         TYPES = Option.TYPES + ('file',)
  1224.         TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
  1225.         TYPE_CHECKER['file'] = check_file
  1226.  
  1227.     
  1228.     def test_extend_file(self):
  1229.         open(test_support.TESTFN, 'w').close()
  1230.         self.assertParseOK([
  1231.             '--file',
  1232.             test_support.TESTFN,
  1233.             '-afoo'], {
  1234.             'file': test_support.TESTFN,
  1235.             'a': 'foo' }, [])
  1236.         os.unlink(test_support.TESTFN)
  1237.  
  1238.     
  1239.     def test_extend_file_nonexistent(self):
  1240.         self.assertParseFail([
  1241.             '--file',
  1242.             test_support.TESTFN,
  1243.             '-afoo'], '%s: file does not exist' % test_support.TESTFN)
  1244.  
  1245.     
  1246.     def test_file_irregular(self):
  1247.         os.mkdir(test_support.TESTFN)
  1248.         self.assertParseFail([
  1249.             '--file',
  1250.             test_support.TESTFN,
  1251.             '-afoo'], '%s: not a regular file' % test_support.TESTFN)
  1252.         os.rmdir(test_support.TESTFN)
  1253.  
  1254.  
  1255.  
  1256. class TestExtendAddActions(BaseTest):
  1257.     
  1258.     def setUp(self):
  1259.         options = [
  1260.             self.MyOption('-a', '--apple', action = 'extend', type = 'string', dest = 'apple')]
  1261.         self.parser = OptionParser(option_list = options)
  1262.  
  1263.     
  1264.     class MyOption(Option):
  1265.         ACTIONS = Option.ACTIONS + ('extend',)
  1266.         STORE_ACTIONS = Option.STORE_ACTIONS + ('extend',)
  1267.         TYPED_ACTIONS = Option.TYPED_ACTIONS + ('extend',)
  1268.         
  1269.         def take_action(self, action, dest, opt, value, values, parser):
  1270.             if action == 'extend':
  1271.                 lvalue = value.split(',')
  1272.                 values.ensure_value(dest, []).extend(lvalue)
  1273.             else:
  1274.                 Option.take_action(self, action, dest, opt, parser, value, values)
  1275.  
  1276.  
  1277.     
  1278.     def test_extend_add_action(self):
  1279.         self.assertParseOK([
  1280.             '-afoo,bar',
  1281.             '--apple=blah'], {
  1282.             'apple': [
  1283.                 'foo',
  1284.                 'bar',
  1285.                 'blah'] }, [])
  1286.  
  1287.     
  1288.     def test_extend_add_action_normal(self):
  1289.         self.assertParseOK([
  1290.             '-a',
  1291.             'foo',
  1292.             '-abar',
  1293.             '--apple=x,y'], {
  1294.             'apple': [
  1295.                 'foo',
  1296.                 'bar',
  1297.                 'x',
  1298.                 'y'] }, [])
  1299.  
  1300.  
  1301.  
  1302. class TestCallback(BaseTest):
  1303.     
  1304.     def setUp(self):
  1305.         options = [
  1306.             make_option('-x', None, action = 'callback', callback = self.process_opt),
  1307.             make_option('-f', '--file', action = 'callback', callback = self.process_opt, type = 'string', dest = 'filename')]
  1308.         self.parser = OptionParser(option_list = options)
  1309.  
  1310.     
  1311.     def process_opt(self, option, opt, value, parser_):
  1312.         if opt == '-x':
  1313.             self.assertEqual(option._short_opts, [
  1314.                 '-x'])
  1315.             self.assertEqual(option._long_opts, [])
  1316.             self.assert_(parser_ is self.parser)
  1317.             self.assert_(value is None)
  1318.             self.assertEqual(vars(parser_.values), {
  1319.                 'filename': None })
  1320.             parser_.values.x = 42
  1321.         elif opt == '--file':
  1322.             self.assertEqual(option._short_opts, [
  1323.                 '-f'])
  1324.             self.assertEqual(option._long_opts, [
  1325.                 '--file'])
  1326.             self.assert_(parser_ is self.parser)
  1327.             self.assertEqual(value, 'foo')
  1328.             self.assertEqual(vars(parser_.values), {
  1329.                 'filename': None,
  1330.                 'x': 42 })
  1331.             setattr(parser_.values, option.dest, value)
  1332.         else:
  1333.             self.fail('Unknown option %r in process_opt.' % opt)
  1334.  
  1335.     
  1336.     def test_callback(self):
  1337.         self.assertParseOK([
  1338.             '-x',
  1339.             '--file=foo'], {
  1340.             'filename': 'foo',
  1341.             'x': 42 }, [])
  1342.  
  1343.     
  1344.     def test_callback_help(self):
  1345.         parser = OptionParser(usage = SUPPRESS_USAGE)
  1346.         parser.remove_option('-h')
  1347.         parser.add_option('-t', '--test', action = 'callback', callback = (lambda : pass), type = 'string', help = 'foo')
  1348.         expected_help = 'options:\n  -t TEST, --test=TEST  foo\n'
  1349.         self.assertHelp(parser, expected_help)
  1350.  
  1351.  
  1352.  
  1353. class TestCallbackExtraArgs(BaseTest):
  1354.     
  1355.     def setUp(self):
  1356.         options = [
  1357.             make_option('-p', '--point', action = 'callback', callback = self.process_tuple, callback_args = (3, int), type = 'string', dest = 'points', default = [])]
  1358.         self.parser = OptionParser(option_list = options)
  1359.  
  1360.     
  1361.     def process_tuple(self, option, opt, value, parser_, len, type):
  1362.         self.assertEqual(len, 3)
  1363.         self.assert_(type is int)
  1364.         if opt == '-p':
  1365.             self.assertEqual(value, '1,2,3')
  1366.         elif opt == '--point':
  1367.             self.assertEqual(value, '4,5,6')
  1368.         
  1369.         value = tuple(map(type, value.split(',')))
  1370.         getattr(parser_.values, option.dest).append(value)
  1371.  
  1372.     
  1373.     def test_callback_extra_args(self):
  1374.         self.assertParseOK([
  1375.             '-p1,2,3',
  1376.             '--point',
  1377.             '4,5,6'], {
  1378.             'points': [
  1379.                 (1, 2, 3),
  1380.                 (4, 5, 6)] }, [])
  1381.  
  1382.  
  1383.  
  1384. class TestCallbackMeddleArgs(BaseTest):
  1385.     
  1386.     def setUp(self):
  1387.         options = [ make_option(str(x), action = 'callback', callback = self.process_n, dest = 'things') for x in range(-1, -6, -1) ]
  1388.         self.parser = OptionParser(option_list = options)
  1389.  
  1390.     
  1391.     def process_n(self, option, opt, value, parser_):
  1392.         nargs = int(opt[1:])
  1393.         rargs = parser_.rargs
  1394.         if len(rargs) < nargs:
  1395.             self.fail('Expected %d arguments for %s option.' % (nargs, opt))
  1396.         
  1397.         dest = parser_.values.ensure_value(option.dest, [])
  1398.         dest.append(tuple(rargs[0:nargs]))
  1399.         parser_.largs.append(nargs)
  1400.         del rargs[0:nargs]
  1401.  
  1402.     
  1403.     def test_callback_meddle_args(self):
  1404.         self.assertParseOK([
  1405.             '-1',
  1406.             'foo',
  1407.             '-3',
  1408.             'bar',
  1409.             'baz',
  1410.             'qux'], {
  1411.             'things': [
  1412.                 ('foo',),
  1413.                 ('bar', 'baz', 'qux')] }, [
  1414.             1,
  1415.             3])
  1416.  
  1417.     
  1418.     def test_callback_meddle_args_separator(self):
  1419.         self.assertParseOK([
  1420.             '-2',
  1421.             'foo',
  1422.             '--'], {
  1423.             'things': [
  1424.                 ('foo', '--')] }, [
  1425.             2])
  1426.  
  1427.  
  1428.  
  1429. class TestCallbackManyArgs(BaseTest):
  1430.     
  1431.     def setUp(self):
  1432.         options = [
  1433.             make_option('-a', '--apple', action = 'callback', nargs = 2, callback = self.process_many, type = 'string'),
  1434.             make_option('-b', '--bob', action = 'callback', nargs = 3, callback = self.process_many, type = 'int')]
  1435.         self.parser = OptionParser(option_list = options)
  1436.  
  1437.     
  1438.     def process_many(self, option, opt, value, parser_):
  1439.         if opt == '-a':
  1440.             self.assertEqual(value, ('foo', 'bar'))
  1441.         elif opt == '--apple':
  1442.             self.assertEqual(value, ('ding', 'dong'))
  1443.         elif opt == '-b':
  1444.             self.assertEqual(value, (1, 2, 3))
  1445.         elif opt == '--bob':
  1446.             self.assertEqual(value, (-666, 42, 0))
  1447.         
  1448.  
  1449.     
  1450.     def test_many_args(self):
  1451.         self.assertParseOK([
  1452.             '-a',
  1453.             'foo',
  1454.             'bar',
  1455.             '--apple',
  1456.             'ding',
  1457.             'dong',
  1458.             '-b',
  1459.             '1',
  1460.             '2',
  1461.             '3',
  1462.             '--bob',
  1463.             '-666',
  1464.             '42',
  1465.             '0'], {
  1466.             'apple': None,
  1467.             'bob': None }, [])
  1468.  
  1469.  
  1470.  
  1471. class TestCallbackCheckAbbrev(BaseTest):
  1472.     
  1473.     def setUp(self):
  1474.         self.parser = OptionParser()
  1475.         self.parser.add_option('--foo-bar', action = 'callback', callback = self.check_abbrev)
  1476.  
  1477.     
  1478.     def check_abbrev(self, option, opt, value, parser):
  1479.         self.assertEqual(opt, '--foo-bar')
  1480.  
  1481.     
  1482.     def test_abbrev_callback_expansion(self):
  1483.         self.assertParseOK([
  1484.             '--foo'], { }, [])
  1485.  
  1486.  
  1487.  
  1488. class TestCallbackVarArgs(BaseTest):
  1489.     
  1490.     def setUp(self):
  1491.         options = [
  1492.             make_option('-a', type = 'int', nargs = 2, dest = 'a'),
  1493.             make_option('-b', action = 'store_true', dest = 'b'),
  1494.             make_option('-c', '--callback', action = 'callback', callback = self.variable_args, dest = 'c')]
  1495.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE, option_list = options)
  1496.  
  1497.     
  1498.     def variable_args(self, option, opt, value, parser):
  1499.         self.assert_(value is None)
  1500.         done = 0
  1501.         value = []
  1502.         rargs = parser.rargs
  1503.         while rargs:
  1504.             arg = rargs[0]
  1505.             if (arg[:2] == '--' or len(arg) > 2 or arg[:1] == '-') and len(arg) > 1 and arg[1] != '-':
  1506.                 break
  1507.                 continue
  1508.             value.append(arg)
  1509.             del rargs[0]
  1510.         setattr(parser.values, option.dest, value)
  1511.  
  1512.     
  1513.     def test_variable_args(self):
  1514.         self.assertParseOK([
  1515.             '-a3',
  1516.             '-5',
  1517.             '--callback',
  1518.             'foo',
  1519.             'bar'], {
  1520.             'a': (3, -5),
  1521.             'b': None,
  1522.             'c': [
  1523.                 'foo',
  1524.                 'bar'] }, [])
  1525.  
  1526.     
  1527.     def test_consume_separator_stop_at_option(self):
  1528.         self.assertParseOK([
  1529.             '-c',
  1530.             '37',
  1531.             '--',
  1532.             'xxx',
  1533.             '-b',
  1534.             'hello'], {
  1535.             'a': None,
  1536.             'b': True,
  1537.             'c': [
  1538.                 '37',
  1539.                 '--',
  1540.                 'xxx'] }, [
  1541.             'hello'])
  1542.  
  1543.     
  1544.     def test_positional_arg_and_variable_args(self):
  1545.         self.assertParseOK([
  1546.             'hello',
  1547.             '-c',
  1548.             'foo',
  1549.             '-',
  1550.             'bar'], {
  1551.             'a': None,
  1552.             'b': None,
  1553.             'c': [
  1554.                 'foo',
  1555.                 '-',
  1556.                 'bar'] }, [
  1557.             'hello'])
  1558.  
  1559.     
  1560.     def test_stop_at_option(self):
  1561.         self.assertParseOK([
  1562.             '-c',
  1563.             'foo',
  1564.             '-b'], {
  1565.             'a': None,
  1566.             'b': True,
  1567.             'c': [
  1568.                 'foo'] }, [])
  1569.  
  1570.     
  1571.     def test_stop_at_invalid_option(self):
  1572.         self.assertParseFail([
  1573.             '-c',
  1574.             '3',
  1575.             '-5',
  1576.             '-a'], 'no such option: -5')
  1577.  
  1578.  
  1579.  
  1580. class ConflictBase(BaseTest):
  1581.     
  1582.     def setUp(self):
  1583.         options = [
  1584.             make_option('-v', '--verbose', action = 'count', dest = 'verbose', help = 'increment verbosity')]
  1585.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE, option_list = options)
  1586.  
  1587.     
  1588.     def show_version(self, option, opt, value, parser):
  1589.         parser.values.show_version = 1
  1590.  
  1591.  
  1592.  
  1593. class TestConflict(ConflictBase):
  1594.     '''Use the default conflict resolution for Optik 1.2: error.'''
  1595.     
  1596.     def assert_conflict_error(self, func):
  1597.         err = self.assertRaises(func, ('-v', '--version'), {
  1598.             'action': 'callback',
  1599.             'callback': self.show_version,
  1600.             'help': 'show version' }, OptionConflictError, 'option -v/--version: conflicting option string(s): -v')
  1601.         self.assertEqual(err.msg, 'conflicting option string(s): -v')
  1602.         self.assertEqual(err.option_id, '-v/--version')
  1603.  
  1604.     
  1605.     def test_conflict_error(self):
  1606.         self.assert_conflict_error(self.parser.add_option)
  1607.  
  1608.     
  1609.     def test_conflict_error_group(self):
  1610.         group = OptionGroup(self.parser, 'Group 1')
  1611.         self.assert_conflict_error(group.add_option)
  1612.  
  1613.     
  1614.     def test_no_such_conflict_handler(self):
  1615.         self.assertRaises(self.parser.set_conflict_handler, ('foo',), None, ValueError, "invalid conflict_resolution value 'foo'")
  1616.  
  1617.  
  1618.  
  1619. class TestConflictResolve(ConflictBase):
  1620.     
  1621.     def setUp(self):
  1622.         ConflictBase.setUp(self)
  1623.         self.parser.set_conflict_handler('resolve')
  1624.         self.parser.add_option('-v', '--version', action = 'callback', callback = self.show_version, help = 'show version')
  1625.  
  1626.     
  1627.     def test_conflict_resolve(self):
  1628.         v_opt = self.parser.get_option('-v')
  1629.         verbose_opt = self.parser.get_option('--verbose')
  1630.         version_opt = self.parser.get_option('--version')
  1631.         self.assert_(v_opt is version_opt)
  1632.         self.assert_(v_opt is not verbose_opt)
  1633.         self.assertEqual(v_opt._long_opts, [
  1634.             '--version'])
  1635.         self.assertEqual(version_opt._short_opts, [
  1636.             '-v'])
  1637.         self.assertEqual(version_opt._long_opts, [
  1638.             '--version'])
  1639.         self.assertEqual(verbose_opt._short_opts, [])
  1640.         self.assertEqual(verbose_opt._long_opts, [
  1641.             '--verbose'])
  1642.  
  1643.     
  1644.     def test_conflict_resolve_help(self):
  1645.         self.assertOutput([
  1646.             '-h'], 'options:\n  --verbose      increment verbosity\n  -h, --help     show this help message and exit\n  -v, --version  show version\n')
  1647.  
  1648.     
  1649.     def test_conflict_resolve_short_opt(self):
  1650.         self.assertParseOK([
  1651.             '-v'], {
  1652.             'verbose': None,
  1653.             'show_version': 1 }, [])
  1654.  
  1655.     
  1656.     def test_conflict_resolve_long_opt(self):
  1657.         self.assertParseOK([
  1658.             '--verbose'], {
  1659.             'verbose': 1 }, [])
  1660.  
  1661.     
  1662.     def test_conflict_resolve_long_opts(self):
  1663.         self.assertParseOK([
  1664.             '--verbose',
  1665.             '--version'], {
  1666.             'verbose': 1,
  1667.             'show_version': 1 }, [])
  1668.  
  1669.  
  1670.  
  1671. class TestConflictOverride(BaseTest):
  1672.     
  1673.     def setUp(self):
  1674.         self.parser = InterceptingOptionParser(usage = SUPPRESS_USAGE)
  1675.         self.parser.set_conflict_handler('resolve')
  1676.         self.parser.add_option('-n', '--dry-run', action = 'store_true', dest = 'dry_run', help = "don't do anything")
  1677.         self.parser.add_option('--dry-run', '-n', action = 'store_const', const = 42, dest = 'dry_run', help = 'dry run mode')
  1678.  
  1679.     
  1680.     def test_conflict_override_opts(self):
  1681.         opt = self.parser.get_option('--dry-run')
  1682.         self.assertEqual(opt._short_opts, [
  1683.             '-n'])
  1684.         self.assertEqual(opt._long_opts, [
  1685.             '--dry-run'])
  1686.  
  1687.     
  1688.     def test_conflict_override_help(self):
  1689.         self.assertOutput([
  1690.             '-h'], 'options:\n  -h, --help     show this help message and exit\n  -n, --dry-run  dry run mode\n')
  1691.  
  1692.     
  1693.     def test_conflict_override_args(self):
  1694.         self.assertParseOK([
  1695.             '-n'], {
  1696.             'dry_run': 42 }, [])
  1697.  
  1698.  
  1699. _expected_help_basic = 'usage: bar.py [options]\n\noptions:\n  -a APPLE           throw APPLEs at basket\n  -b NUM, --boo=NUM  shout "boo!" NUM times (in order to frighten away all the\n                     evil spirits that cause trouble and mayhem)\n  --foo=FOO          store FOO in the foo list for later fooing\n  -h, --help         show this help message and exit\n'
  1700. _expected_help_long_opts_first = 'usage: bar.py [options]\n\noptions:\n  -a APPLE           throw APPLEs at basket\n  --boo=NUM, -b NUM  shout "boo!" NUM times (in order to frighten away all the\n                     evil spirits that cause trouble and mayhem)\n  --foo=FOO          store FOO in the foo list for later fooing\n  --help, -h         show this help message and exit\n'
  1701. _expected_help_title_formatter = 'Usage\n=====\n  bar.py [options]\n\noptions\n=======\n-a APPLE           throw APPLEs at basket\n--boo=NUM, -b NUM  shout "boo!" NUM times (in order to frighten away all the\n                   evil spirits that cause trouble and mayhem)\n--foo=FOO          store FOO in the foo list for later fooing\n--help, -h         show this help message and exit\n'
  1702. _expected_help_short_lines = 'usage: bar.py [options]\n\noptions:\n  -a APPLE           throw APPLEs at basket\n  -b NUM, --boo=NUM  shout "boo!" NUM times (in order to\n                     frighten away all the evil spirits\n                     that cause trouble and mayhem)\n  --foo=FOO          store FOO in the foo list for later\n                     fooing\n  -h, --help         show this help message and exit\n'
  1703.  
  1704. class TestHelp(BaseTest):
  1705.     
  1706.     def setUp(self):
  1707.         self.parser = self.make_parser(80)
  1708.  
  1709.     
  1710.     def make_parser(self, columns):
  1711.         options = [
  1712.             make_option('-a', type = 'string', dest = 'a', metavar = 'APPLE', help = 'throw APPLEs at basket'),
  1713.             make_option('-b', '--boo', type = 'int', dest = 'boo', metavar = 'NUM', help = 'shout "boo!" NUM times (in order to frighten away all the evil spirits that cause trouble and mayhem)'),
  1714.             make_option('--foo', action = 'append', type = 'string', dest = 'foo', help = 'store FOO in the foo list for later fooing')]
  1715.         os.environ['COLUMNS'] = str(columns)
  1716.         return InterceptingOptionParser(option_list = options)
  1717.  
  1718.     
  1719.     def assertHelpEquals(self, expected_output):
  1720.         save_argv = sys.argv[:]
  1721.         
  1722.         try:
  1723.             sys.argv[0] = os.path.join('foo', 'bar.py')
  1724.             self.assertOutput([
  1725.                 '-h'], expected_output)
  1726.         finally:
  1727.             sys.argv[:] = save_argv
  1728.  
  1729.  
  1730.     
  1731.     def test_help(self):
  1732.         self.assertHelpEquals(_expected_help_basic)
  1733.  
  1734.     
  1735.     def test_help_old_usage(self):
  1736.         self.parser.set_usage('usage: %prog [options]')
  1737.         self.assertHelpEquals(_expected_help_basic)
  1738.  
  1739.     
  1740.     def test_help_long_opts_first(self):
  1741.         self.parser.formatter.short_first = 0
  1742.         self.assertHelpEquals(_expected_help_long_opts_first)
  1743.  
  1744.     
  1745.     def test_help_title_formatter(self):
  1746.         self.parser.formatter = TitledHelpFormatter()
  1747.         self.assertHelpEquals(_expected_help_title_formatter)
  1748.  
  1749.     
  1750.     def test_wrap_columns(self):
  1751.         self.parser = self.make_parser(60)
  1752.         self.assertHelpEquals(_expected_help_short_lines)
  1753.  
  1754.     
  1755.     def test_help_description_groups(self):
  1756.         self.parser.set_description('This is the program description for %prog.  %prog has an option group as well as single options.')
  1757.         group = OptionGroup(self.parser, 'Dangerous Options', 'Caution: use of these options is at your own risk.  It is believed that some of them bite.')
  1758.         group.add_option('-g', action = 'store_true', help = 'Group option.')
  1759.         self.parser.add_option_group(group)
  1760.         self.assertHelpEquals('usage: bar.py [options]\n\nThis is the program description for bar.py.  bar.py has an option group as\nwell as single options.\n\noptions:\n  -a APPLE           throw APPLEs at basket\n  -b NUM, --boo=NUM  shout "boo!" NUM times (in order to frighten away all the\n                     evil spirits that cause trouble and mayhem)\n  --foo=FOO          store FOO in the foo list for later fooing\n  -h, --help         show this help message and exit\n\n  Dangerous Options:\n    Caution: use of these options is at your own risk.  It is believed\n    that some of them bite.\n\n    -g               Group option.\n')
  1761.  
  1762.  
  1763.  
  1764. class TestMatchAbbrev(BaseTest):
  1765.     
  1766.     def test_match_abbrev(self):
  1767.         self.assertEqual(_match_abbrev('--f', {
  1768.             '--foz': None,
  1769.             '--foo': None,
  1770.             '--fie': None,
  1771.             '--f': None }), '--f')
  1772.  
  1773.     
  1774.     def test_match_abbrev_error(self):
  1775.         s = '--f'
  1776.         wordmap = {
  1777.             '--foz': None,
  1778.             '--foo': None,
  1779.             '--fie': None }
  1780.         possibilities = ', '.join(wordmap.keys())
  1781.         self.assertRaises(_match_abbrev, (s, wordmap), None, BadOptionError, 'ambiguous option: --f (%s?)' % possibilities)
  1782.  
  1783.  
  1784.  
  1785. def _testclasses():
  1786.     mod = sys.modules[__name__]
  1787.     return _[1]
  1788.  
  1789.  
  1790. def suite():
  1791.     suite = unittest.TestSuite()
  1792.     for testclass in _testclasses():
  1793.         suite.addTest(unittest.makeSuite(testclass))
  1794.     
  1795.     return suite
  1796.  
  1797.  
  1798. def test_main():
  1799.     test_support.run_suite(suite())
  1800.  
  1801. if __name__ == '__main__':
  1802.     unittest.main()
  1803.  
  1804.